home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Plains / Plains Small.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.0 KB  |  1,499 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Plains Small.rmv
  4. //
  5. // Plains definitions for small maps.
  6. //
  7. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  8. // PROPRIETARY and CONFIDENTIAL.
  9. //
  10. // $Creator: Richard Bishop $
  11. // $Current Version: 1.4
  12. // $History
  13. //     V1.0 to V1.1
  14. //        -Added Tigers to maps with two to four players
  15. //      V1.1 to V1.2
  16. //        -Pulled in Berries two tiles closer
  17. //      V1.2 to V1.3
  18. //        -Added Tigers to maps with five and six players
  19. //        -Added Starting Hippos
  20. //    V1.3 to V1.4
  21. //        -Added more neutrals to disperse the trees better.
  22. //////////////////////////////////////////////////////////////////////
  23.  
  24. #if            NOTDEFINED(PLAINS_SMALL_RMV)
  25. #define        (PLAINS_SMALL_RMV,1)
  26.  
  27. //////////////////////////////////////////////////////////////////////
  28. // Definitions we are required to define for plains maps
  29. //////////////////////////////////////////////////////////////////////
  30.  
  31. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  32.   #define  (kBerryPerPlayer,    2)
  33. #else
  34.   #define  (kBerryPerPlayer,    1)
  35. #endif
  36.  
  37. //////////////////////////////////////////////////////////////////////
  38. // Resource Limitations
  39. ResourcePlacementLimit (Gold,     10,    12)
  40. ResourcePlacementLimit (Steel,     10,     12)
  41. ResourcePlacementLimit (Berry,     6,    7)
  42. ResourcePlacementLimit (Stone,  14,    15)
  43. ResourcePlacementLimit (Tree,     3,    5)
  44.  
  45. //////////////////////////////////////////////////////////////////////
  46. // Placing Starting Hippos
  47.  
  48. #if DEFINED(kWinterMap)
  49.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  50.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  51. #else 
  52.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  53.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  54. #endif
  55.  
  56. #if Is2Players
  57. //////////////////////////////////////////////////////////////////////
  58. // 2 PLAYERS...
  59. //////////////////////////////////////////////////////////////////////
  60.  
  61. ResourceSeperation    7 
  62.  
  63. PlaceResourceInRing (Gold, 14, 16)
  64. PlaceResourceInRing (Iron, 15, 17)
  65.  
  66. PlaceWorldUnitInRing (Res-Tiger, 33, 35)
  67. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  68.  
  69. //////////////////////////////////////////////////////////////////////
  70. // terrain definitions
  71. HeightMapSmoothness                    0
  72. #define        (kMaxIntElevation,            8)
  73. #define        (kElevationScale,                Between(.5, .5))
  74. #define        (kHeightMapChaos,                Between(15, 15))
  75.                                             
  76. #define        (kMinimumStartPositionToMapEdge        5)
  77. #define        (kOuterPushFromMapCenter        0)
  78. #define        (kInnerPushFromMapCenter         0)
  79. #define        (kConvergentSampleSize,            32) 
  80. #define        (kConvergentThreshold,            20000)        
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // player definitions
  84. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  85. #define        (kPlayerInnerRadius,            0.7)
  86. #define        (kPlayerOuterRadius,            0.99)
  87. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  88. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  89. #define        (kPlayerLandChaos,            0.8)
  90. #define        (kPlayerLandClumps,            Between(2, 2))
  91. #define        (kPlayerFlatChaos,            0.8)
  92. #define        (kPlayerFlatClumps,            Between(1, 2))
  93. #define        (kPlayerTreePercentage,            0.05)
  94.  
  95.  
  96. //////////////////////////////////////////////////////////////////////
  97. // inner neutral definitions
  98. #define        (kNeutralInnerRadius,            0.2)
  99. #define        (kNeutralOuterRadius,            0.4)
  100. #define        (kNeutralOptimalFactor,            0.7)
  101. #define        (kNumInnerNeutrals,                 Between(15, 15))
  102. #define        (kInnerNeutralPercentLand,        0.2)
  103. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  104. #define        (kInnerNeutralTreePercentage,          0.1)
  105. #define        (kInnerNeutralLandChaos,        0.8)
  106. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  107. #define        (kInnerNeutralFlatChaos,        0.8)
  108. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  109.  
  110.  
  111. //////////////////////////////////////////////////////////////////////
  112. // outer neutral definitions
  113. #define        (kNumOuterNeutrals,            Between(12, 12))
  114. #define        (kOuterNeutralPercentLand,        0.2)
  115. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  116. #define        (kOuterNeutralTreePercentage,          0.25)
  117. #define        (kOuterNeutralLandChaos,        0.8)
  118. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  119. #define        (kOuterNeutralFlatChaos,        0.8)
  120. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  121.  
  122.  
  123. //////////////////////////////////////////////////////////////////////
  124. // resource definitions
  125. #define        (kMaxResourceElevation,            2)
  126. #define        (kResourceToEdgeDistance,        1)
  127. #define        (kResourceToWaterDistance,        1)
  128.  
  129. #define        (kAnimalPerPlayer,                0)
  130. #define        (kAnimalPerNeutral,                0)
  131.  
  132.  
  133. #define        (kBerryPerNeutral,                0)
  134.  
  135. #define        (kFishPerPlayer,                0)
  136. #define        (kFishPerNeutral,                0)
  137.  
  138. #define        (kGoldPerPlayer,                1)
  139. #define        (kGoldPerNeutral,                6)
  140.  
  141. #define        (kOilPerPlayer,                    0)
  142. #define        (kOilPerNeutral,                0)
  143.  
  144. #define        (kSteelPerPlayer,                1)
  145. #define        (kSteelPerNeutral,                6)
  146.  
  147. #define        (kStonePerPlayer,                1)
  148. #define        (kStonePerNeutral,                1)
  149.  
  150. #define        (kTreePerPlayer,                Between(2, 3))
  151. #define        (kTreePerNeutral,                0)
  152.  
  153. //////////////////////////////////////////////////////////////////////
  154. // forest definitions
  155. #define        (kForestFreeRadius,                7.0)
  156. #define        (kForestsPerPlayer,                1)
  157. #define        (kForestChaosLevel,                1)
  158. #define        (kMaxClumpsPerForest,                  2)
  159.  
  160. #elif Is3Players
  161. //////////////////////////////////////////////////////////////////////
  162. // 3 PLAYERS...
  163. //////////////////////////////////////////////////////////////////////
  164.  
  165. PlaceResourceInRing (Gold, 14, 16)
  166. PlaceResourceInRing (Iron, 15, 17)
  167.  
  168. PlaceWorldUnitInRing (Res-Tiger, 33, 35)
  169. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  170.  
  171. ResourceSeperation    5 
  172.  
  173. //////////////////////////////////////////////////////////////////////
  174. // terrain definitions
  175. HeightMapSmoothness                    0
  176. #define        (kMaxIntElevation,            8)
  177. #define        (kElevationScale,                Between(.5, .5))
  178. #define        (kHeightMapChaos,                Between(15, 15))
  179.                                             
  180. #define        (kMinimumStartPositionToMapEdge        6)
  181. #define        (kOuterPushFromMapCenter        0)
  182. #define        (kInnerPushFromMapCenter         0)        
  183.  
  184. //////////////////////////////////////////////////////////////////////
  185. // player definitions
  186. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  187. #define        (kPlayerInnerRadius,            0.7)
  188. #define        (kPlayerOuterRadius,            0.99)
  189. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  190. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  191. #define        (kPlayerLandChaos,            0.8)
  192. #define        (kPlayerLandClumps,            Between(2, 2))
  193. #define        (kPlayerFlatChaos,            0.8)
  194. #define        (kPlayerFlatClumps,            Between(1, 2))
  195. #define        (kPlayerTreePercentage,            0.05)
  196.  
  197.  
  198. //////////////////////////////////////////////////////////////////////
  199. // inner neutral definitions
  200. #define        (kNeutralInnerRadius,            0.2)
  201. #define        (kNeutralOuterRadius,            0.4)
  202. #define        (kNeutralOptimalFactor,            0.7)
  203. #define        (kNumInnerNeutrals,                 Between(13, 13))
  204. #define        (kInnerNeutralPercentLand,        0.2)
  205. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  206. #define        (kInnerNeutralTreePercentage,          0.08)
  207. #define        (kInnerNeutralLandChaos,        0.8)
  208. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  209. #define        (kInnerNeutralFlatChaos,        0.8)
  210. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  211.  
  212.  
  213. //////////////////////////////////////////////////////////////////////
  214. // outer neutral definitions
  215. #define        (kNumOuterNeutrals,            Between(12, 12))
  216. #define        (kOuterNeutralPercentLand,        0.2)
  217. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  218. #define        (kOuterNeutralTreePercentage,          0.25)
  219. #define        (kOuterNeutralLandChaos,        0.8)
  220. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  221. #define        (kOuterNeutralFlatChaos,        0.8)
  222. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  223.  
  224.  
  225. //////////////////////////////////////////////////////////////////////
  226. // resource definitions
  227. #define        (kMaxResourceElevation,            2)
  228. #define        (kResourceToEdgeDistance,        2)
  229. #define        (kResourceToWaterDistance,        3)
  230.  
  231. #define        (kAnimalPerPlayer,                0)
  232. #define        (kAnimalPerNeutral,                0)
  233.  
  234.  
  235. #define        (kBerryPerNeutral,                0)
  236.  
  237. #define        (kFishPerPlayer,                0)
  238. #define        (kFishPerNeutral,                0)
  239.  
  240. #define        (kGoldPerPlayer,                1)
  241. #define        (kGoldPerNeutral,                5)
  242.  
  243. #define        (kOilPerPlayer,                    0)
  244. #define        (kOilPerNeutral,                0)
  245.  
  246. #define        (kSteelPerPlayer,                1)
  247. #define        (kSteelPerNeutral,                5)
  248.  
  249. #define        (kStonePerPlayer,                1)
  250. #define        (kStonePerNeutral,                2)
  251.  
  252. #define        (kTreePerPlayer,                Between(2, 3))
  253. #define        (kTreePerNeutral,                0)
  254.  
  255. //////////////////////////////////////////////////////////////////////
  256. // forest definitions
  257. #define        (kForestFreeRadius,                7.0)
  258. #define        (kForestsPerPlayer,                1)
  259. #define        (kForestChaosLevel,                10)
  260. #define        (kMaxClumpsPerForest,                     2)
  261.  
  262.  
  263. #elif Is4Players
  264. //////////////////////////////////////////////////////////////////////
  265. // 4 PLAYERS...
  266. //////////////////////////////////////////////////////////////////////
  267.  
  268. ResourceSeperation    5 
  269.  
  270. PlaceResourceInRing (Gold, 14, 16)
  271. PlaceResourceInRing (Iron, 15, 17)
  272.  
  273. PlaceWorldUnitInRing (Res-Tiger, 32, 33)
  274. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  275.  
  276. //////////////////////////////////////////////////////////////////////
  277. // terrain definitions
  278. HeightMapSmoothness                    0
  279. #define        (kMaxIntElevation,            8)
  280. #define        (kElevationScale,                Between(.5, .5))
  281. #define        (kHeightMapChaos,                Between(15, 15))
  282.                                             
  283. #define        (kMinimumStartPositionToMapEdge        6)
  284. #define        (kOuterPushFromMapCenter        0)
  285. #define        (kInnerPushFromMapCenter         0)        
  286.  
  287. //////////////////////////////////////////////////////////////////////
  288. // player definitions
  289. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  290. #define        (kPlayerInnerRadius,            0.7)
  291. #define        (kPlayerOuterRadius,            0.99)
  292. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  293. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  294. #define        (kPlayerLandChaos,            0.8)
  295. #define        (kPlayerLandClumps,            Between(2, 2))
  296. #define        (kPlayerFlatChaos,            0.8)
  297. #define        (kPlayerFlatClumps,            Between(1, 2))
  298. #define        (kPlayerTreePercentage,            0.05)
  299.  
  300.  
  301. //////////////////////////////////////////////////////////////////////
  302. // inner neutral definitions
  303. #define        (kNeutralInnerRadius,            0.1)
  304. #define        (kNeutralOuterRadius,            0.4)
  305. #define        (kNeutralOptimalFactor,            0.7)
  306. #define        (kNumInnerNeutrals,                 Between(13, 13))
  307. #define        (kInnerNeutralPercentLand,        0.2)
  308. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  309. #define        (kInnerNeutralTreePercentage,          0.08)
  310. #define        (kInnerNeutralLandChaos,        0.8)
  311. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  312. #define        (kInnerNeutralFlatChaos,        0.8)
  313. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  314.  
  315.  
  316. //////////////////////////////////////////////////////////////////////
  317. // outer neutral definitions
  318. #define        (kNumOuterNeutrals,            Between(12, 12))
  319. #define        (kOuterNeutralPercentLand,        0.15)
  320. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  321. #define        (kOuterNeutralTreePercentage,          0.25)
  322. #define        (kOuterNeutralLandChaos,        0.8)
  323. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  324. #define        (kOuterNeutralFlatChaos,        0.8)
  325. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  326.  
  327.  
  328. //////////////////////////////////////////////////////////////////////
  329. // resource definitions
  330. #define        (kMaxResourceElevation,            2)
  331. #define        (kResourceToEdgeDistance,        2)
  332. #define        (kResourceToWaterDistance,        3)
  333.  
  334. #define        (kAnimalPerPlayer,                0)
  335. #define        (kAnimalPerNeutral,                0)
  336.  
  337.  
  338. #define        (kBerryPerNeutral,                0)
  339.  
  340. #define        (kFishPerPlayer,                0)
  341. #define        (kFishPerNeutral,                0)
  342.  
  343. #define        (kGoldPerPlayer,                1)
  344. #define        (kGoldPerNeutral,                6)
  345.  
  346. #define        (kOilPerPlayer,                    0)
  347. #define        (kOilPerNeutral,                0)
  348.  
  349. #define        (kSteelPerPlayer,                1)
  350. #define        (kSteelPerNeutral,                6)
  351.  
  352. #define        (kStonePerPlayer,                1)
  353. #define        (kStonePerNeutral,                3)
  354.  
  355. #define        (kTreePerPlayer,                Between(2, 3))
  356. #define        (kTreePerNeutral,                0)
  357.  
  358. //////////////////////////////////////////////////////////////////////
  359. // forest definitions
  360. #define        (kForestFreeRadius,                7.0)
  361. #define        (kForestsPerPlayer,                1)
  362. #define        (kForestChaosLevel,                10)
  363. #define        (kMaxClumpsPerForest,                     2)
  364.  
  365. #elif Is5Players
  366. //////////////////////////////////////////////////////////////////////
  367. // 5 PLAYERS...
  368. //////////////////////////////////////////////////////////////////////
  369.  
  370. ResourceSeperation    5 
  371.  
  372. PlaceWorldUnitInRing (Res-Tiger, 25, 26)
  373. PlaceWorldUnitInRing (Res-Tiger, 26, 27)
  374.  
  375. PlaceResourceInRing (Gold, 14, 16)
  376. PlaceResourceInRing (Iron, 15, 17)
  377.  
  378. //////////////////////////////////////////////////////////////////////
  379. // terrain definitions
  380. HeightMapSmoothness                    0
  381. #define        (kMaxIntElevation,            8)
  382. #define        (kElevationScale,                Between(.5, .5))
  383. #define        (kHeightMapChaos,                Between(15, 15))
  384.                                             
  385. #define        (kMinimumStartPositionToMapEdge        6)
  386. #define        (kOuterPushFromMapCenter        0)
  387. #define        (kInnerPushFromMapCenter         0)        
  388.  
  389. //////////////////////////////////////////////////////////////////////
  390. // player definitions
  391. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  392. #define        (kPlayerInnerRadius,            0.7)
  393. #define        (kPlayerOuterRadius,            0.99)
  394. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  395. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  396. #define        (kPlayerLandChaos,            0.8)
  397. #define        (kPlayerLandClumps,            Between(2, 2))
  398. #define        (kPlayerFlatChaos,            0.8)
  399. #define        (kPlayerFlatClumps,            Between(1, 2))
  400. #define        (kPlayerTreePercentage,            0.05)
  401.  
  402.  
  403. //////////////////////////////////////////////////////////////////////
  404. // inner neutral definitions
  405. #define        (kNeutralInnerRadius,            0.2)
  406. #define        (kNeutralOuterRadius,            0.4)
  407. #define        (kNeutralOptimalFactor,            0.7)
  408. #define        (kNumInnerNeutrals,                 Between(12, 12))
  409. #define        (kInnerNeutralPercentLand,        0.2)
  410. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  411. #define        (kInnerNeutralTreePercentage,          0.08)
  412. #define        (kInnerNeutralLandChaos,        0.8)
  413. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  414. #define        (kInnerNeutralFlatChaos,        0.8)
  415. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  416.  
  417.  
  418. //////////////////////////////////////////////////////////////////////
  419. // outer neutral definitions
  420. #define        (kNumOuterNeutrals,            Between(12, 12))
  421. #define        (kOuterNeutralPercentLand,        0.2)
  422. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  423. #define        (kOuterNeutralTreePercentage,          0.25)
  424. #define        (kOuterNeutralLandChaos,        0.8)
  425. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  426. #define        (kOuterNeutralFlatChaos,        0.8)
  427. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  428.  
  429.  
  430. //////////////////////////////////////////////////////////////////////
  431. // resource definitions
  432. #define        (kMaxResourceElevation,            2)
  433. #define        (kResourceToEdgeDistance,        2)
  434. #define        (kResourceToWaterDistance,        3)
  435.  
  436. #define        (kAnimalPerPlayer,                0)
  437. #define        (kAnimalPerNeutral,                0)
  438.  
  439.  
  440. #define        (kBerryPerNeutral,                0)
  441.  
  442. #define        (kFishPerPlayer,                0)
  443. #define        (kFishPerNeutral,                0)
  444.  
  445. #define        (kGoldPerPlayer,                1)
  446. #define        (kGoldPerNeutral,                6)
  447.  
  448. #define        (kOilPerPlayer,                    0)
  449. #define        (kOilPerNeutral,                0)
  450.  
  451. #define        (kSteelPerPlayer,                1)
  452. #define        (kSteelPerNeutral,                6)
  453.  
  454. #define        (kStonePerPlayer,                1)
  455. #define        (kStonePerNeutral,                3)
  456.  
  457. #define        (kTreePerPlayer,                Between(2, 3))
  458. #define        (kTreePerNeutral,                0)
  459.  
  460. //////////////////////////////////////////////////////////////////////
  461. // forest definitions
  462. #define        (kForestFreeRadius,                7.0)
  463. #define        (kForestsPerPlayer,                1)
  464. #define        (kForestChaosLevel,                10)
  465. #define        (kMaxClumpsPerForest,                     2)
  466.  
  467.  
  468. #elif Is6Players
  469. //////////////////////////////////////////////////////////////////////
  470. // 6 PLAYERS...
  471. //////////////////////////////////////////////////////////////////////
  472.  
  473. ResourceSeperation    5 
  474.  
  475. PlaceWorldUnitInRing (Res-Tiger, 20, 21)
  476. PlaceWorldUnitInRing (Res-Tiger, 20, 21)
  477.  
  478. PlaceResourceInRing (Gold, 14, 16)
  479. PlaceResourceInRing (Iron, 15, 17)
  480.  
  481. //////////////////////////////////////////////////////////////////////
  482. // terrain definitions
  483. HeightMapSmoothness                    0
  484. #define        (kMaxIntElevation,            8)
  485. #define        (kElevationScale,                Between(.5, .5))
  486. #define        (kHeightMapChaos,                Between(15, 15))
  487.                                             
  488. #define        (kMinimumStartPositionToMapEdge        6)
  489. #define        (kOuterPushFromMapCenter        0)
  490. #define        (kInnerPushFromMapCenter         0)        
  491.  
  492. //////////////////////////////////////////////////////////////////////
  493. // player definitions
  494. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  495. #define        (kPlayerInnerRadius,            0.7)
  496. #define        (kPlayerOuterRadius,            0.99)
  497. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  498. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  499. #define        (kPlayerLandChaos,            0.8)
  500. #define        (kPlayerLandClumps,            Between(2, 2))
  501. #define        (kPlayerFlatChaos,            0.8)
  502. #define        (kPlayerFlatClumps,            Between(1, 2))
  503. #define        (kPlayerTreePercentage,            0.05)
  504.  
  505.  
  506. //////////////////////////////////////////////////////////////////////
  507. // inner neutral definitions
  508. #define        (kNeutralInnerRadius,            0.2)
  509. #define        (kNeutralOuterRadius,            0.4)
  510. #define        (kNeutralOptimalFactor,            0.7)
  511. #define        (kNumInnerNeutrals,                 Between(11, 11))
  512. #define        (kInnerNeutralPercentLand,        0.2)
  513. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  514. #define        (kInnerNeutralTreePercentage,          0.08)
  515. #define        (kInnerNeutralLandChaos,        0.8)
  516. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  517. #define        (kInnerNeutralFlatChaos,        0.8)
  518. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  519.  
  520.  
  521. //////////////////////////////////////////////////////////////////////
  522. // outer neutral definitions
  523. #define        (kNumOuterNeutrals,            Between(11, 11))
  524. #define        (kOuterNeutralPercentLand,        0.2)
  525. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  526. #define        (kOuterNeutralTreePercentage,          0.25)
  527. #define        (kOuterNeutralLandChaos,        0.8)
  528. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  529. #define        (kOuterNeutralFlatChaos,        0.8)
  530. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  531.  
  532.  
  533. //////////////////////////////////////////////////////////////////////
  534. // resource definitions
  535. #define        (kMaxResourceElevation,            2)
  536. #define        (kResourceToEdgeDistance,        2)
  537. #define        (kResourceToWaterDistance,        3)
  538.  
  539. #define        (kAnimalPerPlayer,                0)
  540. #define        (kAnimalPerNeutral,                0)
  541.  
  542.  
  543. #define        (kBerryPerNeutral,                0)
  544.  
  545. #define        (kFishPerPlayer,                0)
  546. #define        (kFishPerNeutral,                0)
  547.  
  548. #define        (kGoldPerPlayer,                1)
  549. #define        (kGoldPerNeutral,                5)
  550.  
  551. #define        (kOilPerPlayer,                    0)
  552. #define        (kOilPerNeutral,                0)
  553.  
  554. #define        (kSteelPerPlayer,                1)
  555. #define        (kSteelPerNeutral,                5)
  556.  
  557. #define        (kStonePerPlayer,                1)
  558. #define        (kStonePerNeutral,                2)
  559.  
  560. #define        (kTreePerPlayer,                Between(2, 3))
  561. #define        (kTreePerNeutral,                0)
  562.  
  563. //////////////////////////////////////////////////////////////////////
  564. // forest definitions
  565. #define        (kForestFreeRadius,                7.0)
  566. #define        (kForestsPerPlayer,                1)
  567. #define        (kForestChaosLevel,                10)
  568. #define        (kMaxClumpsPerForest,                     2)
  569.  
  570. #elif Is7Players
  571. //////////////////////////////////////////////////////////////////////
  572. // 7 PLAYERS...
  573. //////////////////////////////////////////////////////////////////////
  574.  
  575. ResourceSeperation    4 
  576.  
  577. //////////////////////////////////////////////////////////////////////
  578. // terrain definitions
  579. HeightMapSmoothness                    0
  580. #define        (kMaxIntElevation,            8)
  581. #define        (kElevationScale,                Between(.5, .5))
  582. #define        (kHeightMapChaos,                Between(15, 15))
  583.                                             
  584. #define        (kMinimumStartPositionToMapEdge        6)
  585. #define        (kOuterPushFromMapCenter        0)
  586. #define        (kInnerPushFromMapCenter         0)        
  587.  
  588. //////////////////////////////////////////////////////////////////////
  589. // player definitions
  590. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  591. #define        (kPlayerInnerRadius,            0.7)
  592. #define        (kPlayerOuterRadius,            0.99)
  593. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  594. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  595. #define        (kPlayerLandChaos,            0.8)
  596. #define        (kPlayerLandClumps,            Between(2, 2))
  597. #define        (kPlayerFlatChaos,            0.8)
  598. #define        (kPlayerFlatClumps,            Between(1, 2))
  599. #define        (kPlayerTreePercentage,            0.05)
  600.  
  601.  
  602. //////////////////////////////////////////////////////////////////////
  603. // inner neutral definitions
  604. #define        (kNeutralInnerRadius,            0.2)
  605. #define        (kNeutralOuterRadius,            0.4)
  606. #define        (kNeutralOptimalFactor,            0.7)
  607. #define        (kNumInnerNeutrals,                 Between(11, 11))
  608. #define        (kInnerNeutralPercentLand,        0.2)
  609. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  610. #define        (kInnerNeutralTreePercentage,          0.08)
  611. #define        (kInnerNeutralLandChaos,        0.8)
  612. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  613. #define        (kInnerNeutralFlatChaos,        0.8)
  614. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  615.  
  616.  
  617. //////////////////////////////////////////////////////////////////////
  618. // outer neutral definitions
  619. #define        (kNumOuterNeutrals,            Between(11, 11))
  620. #define        (kOuterNeutralPercentLand,        0.2)
  621. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  622. #define        (kOuterNeutralTreePercentage,          0.25)
  623. #define        (kOuterNeutralLandChaos,        0.8)
  624. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  625. #define        (kOuterNeutralFlatChaos,        0.8)
  626. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  627.  
  628.  
  629. //////////////////////////////////////////////////////////////////////
  630. // resource definitions
  631. #define        (kMaxResourceElevation,            2)
  632. #define        (kResourceToEdgeDistance,        2)
  633. #define        (kResourceToWaterDistance,        3)
  634.  
  635. #define        (kAnimalPerPlayer,                0)
  636. #define        (kAnimalPerNeutral,                0)
  637.  
  638.  
  639. #define        (kBerryPerNeutral,                0)
  640.  
  641. #define        (kFishPerPlayer,                0)
  642. #define        (kFishPerNeutral,                0)
  643.  
  644. #define        (kGoldPerPlayer,                1)
  645. #define        (kGoldPerNeutral,                8)
  646.  
  647. #define        (kOilPerPlayer,                    0)
  648. #define        (kOilPerNeutral,                0)
  649.  
  650. #define        (kSteelPerPlayer,                1)
  651. #define        (kSteelPerNeutral,                8)
  652.  
  653. #define        (kStonePerPlayer,                1)
  654. #define        (kStonePerNeutral,                2)
  655.  
  656. #define        (kTreePerPlayer,                Between(2, 3))
  657. #define        (kTreePerNeutral,                0)
  658.  
  659. //////////////////////////////////////////////////////////////////////
  660. // forest definitions
  661. #define        (kForestFreeRadius,                7.0)
  662. #define        (kForestsPerPlayer,                1)
  663. #define        (kForestChaosLevel,                10)
  664. #define        (kMaxClumpsPerForest,                     2)
  665.  
  666. #elif Is8Players
  667. //////////////////////////////////////////////////////////////////////
  668. // 8 PLAYERS...
  669. //////////////////////////////////////////////////////////////////////
  670.  
  671. ResourceSeperation    4 
  672.  
  673. //////////////////////////////////////////////////////////////////////
  674. // terrain definitions
  675. HeightMapSmoothness                    0
  676. #define        (kMaxIntElevation,            8)
  677. #define        (kElevationScale,                Between(.5, .5))
  678. #define        (kHeightMapChaos,                Between(15, 15))
  679.                                             
  680. #define        (kMinimumStartPositionToMapEdge        6)
  681. #define        (kOuterPushFromMapCenter        0)
  682. #define        (kInnerPushFromMapCenter         0)        
  683.  
  684. //////////////////////////////////////////////////////////////////////
  685. // player definitions
  686. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  687. #define        (kPlayerInnerRadius,            0.7)
  688. #define        (kPlayerOuterRadius,            0.99)
  689. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  690. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  691. #define        (kPlayerLandChaos,            0.8)
  692. #define        (kPlayerLandClumps,            Between(2, 2))
  693. #define        (kPlayerFlatChaos,            0.8)
  694. #define        (kPlayerFlatClumps,            Between(1, 2))
  695. #define        (kPlayerTreePercentage,            0.05)
  696.  
  697.  
  698. //////////////////////////////////////////////////////////////////////
  699. // inner neutral definitions
  700. #define        (kNeutralInnerRadius,            0.2)
  701. #define        (kNeutralOuterRadius,            0.4)
  702. #define        (kNeutralOptimalFactor,            0.7)
  703. #define        (kNumInnerNeutrals,                 Between(10, 10))
  704. #define        (kInnerNeutralPercentLand,        0.2)
  705. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  706. #define        (kInnerNeutralTreePercentage,          0.08)
  707. #define        (kInnerNeutralLandChaos,        0.8)
  708. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  709. #define        (kInnerNeutralFlatChaos,        0.8)
  710. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  711.  
  712.  
  713. //////////////////////////////////////////////////////////////////////
  714. // outer neutral definitions
  715. #define        (kNumOuterNeutrals,            Between(10, 10))
  716. #define        (kOuterNeutralPercentLand,        0.2)
  717. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  718. #define        (kOuterNeutralTreePercentage,          0.25)
  719. #define        (kOuterNeutralLandChaos,        0.8)
  720. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  721. #define        (kOuterNeutralFlatChaos,        0.8)
  722. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  723.  
  724.  
  725. //////////////////////////////////////////////////////////////////////
  726. // resource definitions
  727. #define        (kMaxResourceElevation,            2)
  728. #define        (kResourceToEdgeDistance,        2)
  729. #define        (kResourceToWaterDistance,        3)
  730.  
  731. #define        (kAnimalPerPlayer,                0)
  732. #define        (kAnimalPerNeutral,                0)
  733.  
  734.  
  735. #define        (kBerryPerNeutral,                0)
  736.  
  737. #define        (kFishPerPlayer,                0)
  738. #define        (kFishPerNeutral,                0)
  739.  
  740. #define        (kGoldPerPlayer,                1)
  741. #define        (kGoldPerNeutral,                7)
  742.  
  743. #define        (kOilPerPlayer,                    0)
  744. #define        (kOilPerNeutral,                0)
  745.  
  746. #define        (kSteelPerPlayer,                1)
  747. #define        (kSteelPerNeutral,                7)
  748.  
  749. #define        (kStonePerPlayer,                1)
  750. #define        (kStonePerNeutral,                2)
  751.  
  752. #define        (kTreePerPlayer,                Between(2, 3))
  753. #define        (kTreePerNeutral,                0)
  754.  
  755. //////////////////////////////////////////////////////////////////////
  756. // forest definitions
  757. #define        (kForestFreeRadius,                7.0)
  758. #define        (kForestsPerPlayer,                1)
  759. #define        (kForestChaosLevel,                10)
  760. #define        (kMaxClumpsPerForest,                     2)
  761.  
  762. #elif Is9Players
  763. //////////////////////////////////////////////////////////////////////
  764. // 9 PLAYERS...
  765. //////////////////////////////////////////////////////////////////////
  766.  
  767. //////////////////////////////////////////////////////////////////////
  768. // terrain definitions
  769. #define        (kMaxIntElevation,            15)
  770. #define        (kElevationScale,                Between(1, 1))
  771. #define        (kHeightMapChaos,                Between(20, 60))
  772.  
  773. #define        (kMinimumStartPositionToMapEdge    2)
  774. #define        (kOuterPushFromMapCenter        20)
  775. #define        (kInnerPushFromMapCenter         0)    
  776.                                             
  777. //////////////////////////////////////////////////////////////////////
  778. // player definitions
  779. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  780. #define        (kPlayerInnerRadius,            0.6)
  781. #define        (kPlayerOuterRadius,            0.95)
  782. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  783. #define        (kPlayerPercentFlat,            Between(.9, .9))
  784. #define        (kPlayerLandChaos,            0.8)
  785. #define        (kPlayerLandClumps,            Between(2, 2))
  786. #define        (kPlayerFlatChaos,            0.8)
  787. #define        (kPlayerFlatClumps,            Between(1, 2))
  788. #define        (kPlayerTreePercentage,            0.08)
  789.  
  790. //////////////////////////////////////////////////////////////////////
  791. // inner neutral definitions
  792. #define        (kNeutralInnerRadius,            0.3)
  793. #define        (kNeutralOuterRadius,            0.4)
  794. #define        (kNeutralOptimalFactor,            0.7)
  795. #define        (kNumInnerNeutrals,                 Between(10, 10))
  796. #define        (kInnerNeutralPercentLand,        0.19)
  797. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  798. #define        (kInnerNeutralTreePercentage,          0.15)
  799. #define        (kInnerNeutralLandChaos,        0.8)
  800. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  801. #define        (kInnerNeutralFlatChaos,        0.8)
  802. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  803.  
  804. //////////////////////////////////////////////////////////////////////
  805. // outer neutral definitions
  806. #define        (kNumOuterNeutrals,            Between(10, 10))
  807. #define        (kOuterNeutralPercentLand,        0.2)
  808. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  809. #define        (kOuterNeutralTreePercentage,          0.25)
  810. #define        (kOuterNeutralLandChaos,        0.8)
  811. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  812. #define        (kOuterNeutralFlatChaos,        0.8)
  813. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  814.  
  815. //////////////////////////////////////////////////////////////////////
  816. // resource definitions
  817. #define        (kMaxResourceElevation,            4)
  818. #define        (kResourceToEdgeDistance,        2)
  819. #define        (kResourceToWaterDistance,        4)
  820.  
  821. #define        (kAnimalPerPlayer,            0)
  822. #define        (kAnimalPerNeutral,            0)
  823.  
  824.  
  825. #define        (kBerryPerNeutral,            0)
  826.  
  827. #define        (kFishPerPlayer,                0)
  828. #define        (kFishPerNeutral,                0)
  829.  
  830. #define        (kGoldPerPlayer,                2)
  831. #define        (kGoldPerNeutral,                2)
  832.  
  833. #define        (kOilPerPlayer,                0)
  834. #define        (kOilPerNeutral,                0)
  835.  
  836. #define        (kSteelPerPlayer,                2)
  837. #define        (kSteelPerNeutral,            2)
  838.  
  839. #define        (kStonePerPlayer,                1)
  840. #define        (kStonePerNeutral,            5)
  841.  
  842. #define        (kTreePerPlayer,                0)
  843. #define        (kTreePerNeutral,                0)
  844.  
  845.  
  846. //////////////////////////////////////////////////////////////////////
  847. // forest definitions
  848. #define        (kForestFreeRadius,                7.0)
  849. #define        (kForestsPerPlayer,                1 )
  850. #define        (kForestChaosLevel,                1)
  851. #define        (kMaxClumpsPerForest,                  2)
  852.  
  853. #elif Is10Players
  854. //////////////////////////////////////////////////////////////////////
  855. // 10 PLAYERS...
  856. //////////////////////////////////////////////////////////////////////
  857.  
  858. //////////////////////////////////////////////////////////////////////
  859. // terrain definitions
  860. #define        (kMaxIntElevation,            15)
  861. #define        (kElevationScale,                Between(1, 1))
  862. #define        (kHeightMapChaos,                Between(20, 60))
  863.  
  864. #define        (kMinimumStartPositionToMapEdge    2)
  865. #define        (kOuterPushFromMapCenter        20)
  866. #define        (kInnerPushFromMapCenter         0)    
  867.                                             
  868. //////////////////////////////////////////////////////////////////////
  869. // player definitions
  870. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  871. #define        (kPlayerInnerRadius,            0.6)
  872. #define        (kPlayerOuterRadius,            0.95)
  873. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  874. #define        (kPlayerPercentFlat,            Between(.9, .9))
  875. #define        (kPlayerLandChaos,            0.8)
  876. #define        (kPlayerLandClumps,            Between(2, 2))
  877. #define        (kPlayerFlatChaos,            0.8)
  878. #define        (kPlayerFlatClumps,            Between(1, 2))
  879. #define        (kPlayerTreePercentage,            0.08)
  880.  
  881. //////////////////////////////////////////////////////////////////////
  882. // inner neutral definitions
  883. #define        (kNeutralInnerRadius,            0.3)
  884. #define        (kNeutralOuterRadius,            0.4)
  885. #define        (kNeutralOptimalFactor,            0.7)
  886. #define        (kNumInnerNeutrals,                 Between(10, 10))
  887. #define        (kInnerNeutralPercentLand,        0.19)
  888. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  889. #define        (kInnerNeutralTreePercentage,          0.15)
  890. #define        (kInnerNeutralLandChaos,        0.8)
  891. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  892. #define        (kInnerNeutralFlatChaos,        0.8)
  893. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  894.  
  895. //////////////////////////////////////////////////////////////////////
  896. // outer neutral definitions
  897. #define        (kNumOuterNeutrals,            Between(10, 10))
  898. #define        (kOuterNeutralPercentLand,        0.2)
  899. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  900. #define        (kOuterNeutralTreePercentage,          0.25)
  901. #define        (kOuterNeutralLandChaos,        0.8)
  902. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  903. #define        (kOuterNeutralFlatChaos,        0.8)
  904. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  905.  
  906. //////////////////////////////////////////////////////////////////////
  907. // resource definitions
  908. #define        (kMaxResourceElevation,            4)
  909. #define        (kResourceToEdgeDistance,        2)
  910. #define        (kResourceToWaterDistance,        4)
  911.  
  912. #define        (kAnimalPerPlayer,            0)
  913. #define        (kAnimalPerNeutral,            0)
  914.  
  915.  
  916. #define        (kBerryPerNeutral,            0)
  917.  
  918. #define        (kFishPerPlayer,                0)
  919. #define        (kFishPerNeutral,                0)
  920.  
  921. #define        (kGoldPerPlayer,                2)
  922. #define        (kGoldPerNeutral,                2)
  923.  
  924. #define        (kOilPerPlayer,                0)
  925. #define        (kOilPerNeutral,                0)
  926.  
  927. #define        (kSteelPerPlayer,                2)
  928. #define        (kSteelPerNeutral,            2)
  929.  
  930. #define        (kStonePerPlayer,                1)
  931. #define        (kStonePerNeutral,            5)
  932.  
  933. #define        (kTreePerPlayer,                0)
  934. #define        (kTreePerNeutral,                0)
  935.  
  936.  
  937. //////////////////////////////////////////////////////////////////////
  938. // forest definitions
  939. #define        (kForestFreeRadius,                7.0)
  940. #define        (kForestsPerPlayer,                1 )
  941. #define        (kForestChaosLevel,                1)
  942. #define        (kMaxClumpsPerForest,                  2)
  943.  
  944.  
  945. #elif Is11Players
  946. //////////////////////////////////////////////////////////////////////
  947. // 11 PLAYERS...
  948. //////////////////////////////////////////////////////////////////////
  949.  
  950. //////////////////////////////////////////////////////////////////////
  951. // terrain definitions
  952. #define        (kMaxIntElevation,            15)
  953. #define        (kElevationScale,                Between(1, 1))
  954. #define        (kHeightMapChaos,                Between(20, 60))
  955.  
  956. #define        (kMinimumStartPositionToMapEdge    2)
  957. #define        (kOuterPushFromMapCenter        20)
  958. #define        (kInnerPushFromMapCenter         0)    
  959.                                             
  960. //////////////////////////////////////////////////////////////////////
  961. // player definitions
  962. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  963. #define        (kPlayerInnerRadius,            0.6)
  964. #define        (kPlayerOuterRadius,            0.95)
  965. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  966. #define        (kPlayerPercentFlat,            Between(.9, .9))
  967. #define        (kPlayerLandChaos,            0.8)
  968. #define        (kPlayerLandClumps,            Between(2, 2))
  969. #define        (kPlayerFlatChaos,            0.8)
  970. #define        (kPlayerFlatClumps,            Between(1, 2))
  971. #define        (kPlayerTreePercentage,            0.08)
  972.  
  973. //////////////////////////////////////////////////////////////////////
  974. // inner neutral definitions
  975. #define        (kNeutralInnerRadius,            0.3)
  976. #define        (kNeutralOuterRadius,            0.4)
  977. #define        (kNeutralOptimalFactor,            0.7)
  978. #define        (kNumInnerNeutrals,                 Between(10, 10))
  979. #define        (kInnerNeutralPercentLand,        0.19)
  980. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  981. #define        (kInnerNeutralTreePercentage,          0.15)
  982. #define        (kInnerNeutralLandChaos,        0.8)
  983. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  984. #define        (kInnerNeutralFlatChaos,        0.8)
  985. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  986.  
  987. //////////////////////////////////////////////////////////////////////
  988. // outer neutral definitions
  989. #define        (kNumOuterNeutrals,            Between(10, 10))
  990. #define        (kOuterNeutralPercentLand,        0.2)
  991. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  992. #define        (kOuterNeutralTreePercentage,          0.25)
  993. #define        (kOuterNeutralLandChaos,        0.8)
  994. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  995. #define        (kOuterNeutralFlatChaos,        0.8)
  996. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  997.  
  998. //////////////////////////////////////////////////////////////////////
  999. // resource definitions
  1000. #define        (kMaxResourceElevation,            4)
  1001. #define        (kResourceToEdgeDistance,        2)
  1002. #define        (kResourceToWaterDistance,        4)
  1003.  
  1004. #define        (kAnimalPerPlayer,            0)
  1005. #define        (kAnimalPerNeutral,            0)
  1006.  
  1007.  
  1008. #define        (kBerryPerNeutral,            0)
  1009.  
  1010. #define        (kFishPerPlayer,                0)
  1011. #define        (kFishPerNeutral,                0)
  1012.  
  1013. #define        (kGoldPerPlayer,                2)
  1014. #define        (kGoldPerNeutral,                2)
  1015.  
  1016. #define        (kOilPerPlayer,                0)
  1017. #define        (kOilPerNeutral,                0)
  1018.  
  1019. #define        (kSteelPerPlayer,                2)
  1020. #define        (kSteelPerNeutral,            2)
  1021.  
  1022. #define        (kStonePerPlayer,                1)
  1023. #define        (kStonePerNeutral,            5)
  1024.  
  1025. #define        (kTreePerPlayer,                0)
  1026. #define        (kTreePerNeutral,                0)
  1027.  
  1028.  
  1029. //////////////////////////////////////////////////////////////////////
  1030. // forest definitions
  1031. #define        (kForestFreeRadius,                7.0)
  1032. #define        (kForestsPerPlayer,                1 )
  1033. #define        (kForestChaosLevel,                1)
  1034. #define        (kMaxClumpsPerForest,                  2)
  1035.  
  1036.  
  1037. #elif Is12Players
  1038. //////////////////////////////////////////////////////////////////////
  1039. // 12 PLAYERS...
  1040. //////////////////////////////////////////////////////////////////////
  1041.  
  1042. //////////////////////////////////////////////////////////////////////
  1043. // terrain definitions
  1044. #define        (kMaxIntElevation,            15)
  1045. #define        (kElevationScale,                Between(1, 1))
  1046. #define        (kHeightMapChaos,                Between(20, 60))
  1047.  
  1048. #define        (kMinimumStartPositionToMapEdge    2)
  1049. #define        (kOuterPushFromMapCenter        20)
  1050. #define        (kInnerPushFromMapCenter         0)    
  1051.                                             
  1052. //////////////////////////////////////////////////////////////////////
  1053. // player definitions
  1054. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1055. #define        (kPlayerInnerRadius,            0.6)
  1056. #define        (kPlayerOuterRadius,            0.95)
  1057. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1058. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1059. #define        (kPlayerLandChaos,            0.8)
  1060. #define        (kPlayerLandClumps,            Between(2, 2))
  1061. #define        (kPlayerFlatChaos,            0.8)
  1062. #define        (kPlayerFlatClumps,            Between(1, 2))
  1063. #define        (kPlayerTreePercentage,            0.08)
  1064.  
  1065. //////////////////////////////////////////////////////////////////////
  1066. // inner neutral definitions
  1067. #define        (kNeutralInnerRadius,            0.3)
  1068. #define        (kNeutralOuterRadius,            0.4)
  1069. #define        (kNeutralOptimalFactor,            0.7)
  1070. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1071. #define        (kInnerNeutralPercentLand,        0.19)
  1072. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1073. #define        (kInnerNeutralTreePercentage,          0.15)
  1074. #define        (kInnerNeutralLandChaos,        0.8)
  1075. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1076. #define        (kInnerNeutralFlatChaos,        0.8)
  1077. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1078.  
  1079. //////////////////////////////////////////////////////////////////////
  1080. // outer neutral definitions
  1081. #define        (kNumOuterNeutrals,            Between(10, 10))
  1082. #define        (kOuterNeutralPercentLand,        0.2)
  1083. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1084. #define        (kOuterNeutralTreePercentage,          0.25)
  1085. #define        (kOuterNeutralLandChaos,        0.8)
  1086. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1087. #define        (kOuterNeutralFlatChaos,        0.8)
  1088. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1089.  
  1090. //////////////////////////////////////////////////////////////////////
  1091. // resource definitions
  1092. #define        (kMaxResourceElevation,            4)
  1093. #define        (kResourceToEdgeDistance,        2)
  1094. #define        (kResourceToWaterDistance,        4)
  1095.  
  1096. #define        (kAnimalPerPlayer,            0)
  1097. #define        (kAnimalPerNeutral,            0)
  1098.  
  1099.  
  1100. #define        (kBerryPerNeutral,            0)
  1101.  
  1102. #define        (kFishPerPlayer,                0)
  1103. #define        (kFishPerNeutral,                0)
  1104.  
  1105. #define        (kGoldPerPlayer,                2)
  1106. #define        (kGoldPerNeutral,                2)
  1107.  
  1108. #define        (kOilPerPlayer,                0)
  1109. #define        (kOilPerNeutral,                0)
  1110.  
  1111. #define        (kSteelPerPlayer,                2)
  1112. #define        (kSteelPerNeutral,            2)
  1113.  
  1114. #define        (kStonePerPlayer,                1)
  1115. #define        (kStonePerNeutral,            5)
  1116.  
  1117. #define        (kTreePerPlayer,                0)
  1118. #define        (kTreePerNeutral,                0)
  1119.  
  1120.  
  1121. //////////////////////////////////////////////////////////////////////
  1122. // forest definitions
  1123. #define        (kForestFreeRadius,                7.0)
  1124. #define        (kForestsPerPlayer,                1 )
  1125. #define        (kForestChaosLevel,                1)
  1126. #define        (kMaxClumpsPerForest,                  2)
  1127.  
  1128. #elif Is13Players
  1129. //////////////////////////////////////////////////////////////////////
  1130. // 13 PLAYERS...
  1131. //////////////////////////////////////////////////////////////////////
  1132.  
  1133. //////////////////////////////////////////////////////////////////////
  1134. // terrain definitions
  1135. #define        (kMaxIntElevation,            15)
  1136. #define        (kElevationScale,                Between(1, 1))
  1137. #define        (kHeightMapChaos,                Between(20, 60))
  1138.  
  1139. #define        (kMinimumStartPositionToMapEdge    2)
  1140. #define        (kOuterPushFromMapCenter        20)
  1141. #define        (kInnerPushFromMapCenter         0)    
  1142.                                             
  1143. //////////////////////////////////////////////////////////////////////
  1144. // player definitions
  1145. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1146. #define        (kPlayerInnerRadius,            0.6)
  1147. #define        (kPlayerOuterRadius,            0.95)
  1148. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1149. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1150. #define        (kPlayerLandChaos,            0.8)
  1151. #define        (kPlayerLandClumps,            Between(2, 2))
  1152. #define        (kPlayerFlatChaos,            0.8)
  1153. #define        (kPlayerFlatClumps,            Between(1, 2))
  1154. #define        (kPlayerTreePercentage,            0.08)
  1155.  
  1156. //////////////////////////////////////////////////////////////////////
  1157. // inner neutral definitions
  1158. #define        (kNeutralInnerRadius,            0.3)
  1159. #define        (kNeutralOuterRadius,            0.4)
  1160. #define        (kNeutralOptimalFactor,            0.7)
  1161. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1162. #define        (kInnerNeutralPercentLand,        0.19)
  1163. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1164. #define        (kInnerNeutralTreePercentage,          0.15)
  1165. #define        (kInnerNeutralLandChaos,        0.8)
  1166. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1167. #define        (kInnerNeutralFlatChaos,        0.8)
  1168. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1169.  
  1170. //////////////////////////////////////////////////////////////////////
  1171. // outer neutral definitions
  1172. #define        (kNumOuterNeutrals,            Between(10, 10))
  1173. #define        (kOuterNeutralPercentLand,        0.2)
  1174. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1175. #define        (kOuterNeutralTreePercentage,          0.25)
  1176. #define        (kOuterNeutralLandChaos,        0.8)
  1177. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1178. #define        (kOuterNeutralFlatChaos,        0.8)
  1179. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1180.  
  1181. //////////////////////////////////////////////////////////////////////
  1182. // resource definitions
  1183. #define        (kMaxResourceElevation,            4)
  1184. #define        (kResourceToEdgeDistance,        2)
  1185. #define        (kResourceToWaterDistance,        4)
  1186.  
  1187. #define        (kAnimalPerPlayer,            0)
  1188. #define        (kAnimalPerNeutral,            0)
  1189.  
  1190.  
  1191. #define        (kBerryPerNeutral,            0)
  1192.  
  1193. #define        (kFishPerPlayer,                0)
  1194. #define        (kFishPerNeutral,                0)
  1195.  
  1196. #define        (kGoldPerPlayer,                2)
  1197. #define        (kGoldPerNeutral,                2)
  1198.  
  1199. #define        (kOilPerPlayer,                0)
  1200. #define        (kOilPerNeutral,                0)
  1201.  
  1202. #define        (kSteelPerPlayer,                2)
  1203. #define        (kSteelPerNeutral,            2)
  1204.  
  1205. #define        (kStonePerPlayer,                1)
  1206. #define        (kStonePerNeutral,            5)
  1207.  
  1208. #define        (kTreePerPlayer,                0)
  1209. #define        (kTreePerNeutral,                0)
  1210.  
  1211.  
  1212. //////////////////////////////////////////////////////////////////////
  1213. // forest definitions
  1214. #define        (kForestFreeRadius,                7.0)
  1215. #define        (kForestsPerPlayer,                1 )
  1216. #define        (kForestChaosLevel,                1)
  1217. #define        (kMaxClumpsPerForest,                  2)
  1218.  
  1219.  
  1220. #elif Is14Players
  1221. //////////////////////////////////////////////////////////////////////
  1222. // 14 PLAYERS...
  1223. //////////////////////////////////////////////////////////////////////
  1224.  
  1225. //////////////////////////////////////////////////////////////////////
  1226. // terrain definitions
  1227. #define        (kMaxIntElevation,            15)
  1228. #define        (kElevationScale,                Between(1, 1))
  1229. #define        (kHeightMapChaos,                Between(20, 60))
  1230.  
  1231. #define        (kMinimumStartPositionToMapEdge    2)
  1232. #define        (kOuterPushFromMapCenter        20)
  1233. #define        (kInnerPushFromMapCenter         0)    
  1234.                                             
  1235. //////////////////////////////////////////////////////////////////////
  1236. // player definitions
  1237. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1238. #define        (kPlayerInnerRadius,            0.6)
  1239. #define        (kPlayerOuterRadius,            0.95)
  1240. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1241. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1242. #define        (kPlayerLandChaos,            0.8)
  1243. #define        (kPlayerLandClumps,            Between(2, 2))
  1244. #define        (kPlayerFlatChaos,            0.8)
  1245. #define        (kPlayerFlatClumps,            Between(1, 2))
  1246. #define        (kPlayerTreePercentage,            0.08)
  1247.  
  1248. //////////////////////////////////////////////////////////////////////
  1249. // inner neutral definitions
  1250. #define        (kNeutralInnerRadius,            0.3)
  1251. #define        (kNeutralOuterRadius,            0.4)
  1252. #define        (kNeutralOptimalFactor,            0.7)
  1253. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1254. #define        (kInnerNeutralPercentLand,        0.19)
  1255. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1256. #define        (kInnerNeutralTreePercentage,          0.15)
  1257. #define        (kInnerNeutralLandChaos,        0.8)
  1258. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1259. #define        (kInnerNeutralFlatChaos,        0.8)
  1260. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1261.  
  1262. //////////////////////////////////////////////////////////////////////
  1263. // outer neutral definitions
  1264. #define        (kNumOuterNeutrals,            Between(10, 10))
  1265. #define        (kOuterNeutralPercentLand,        0.2)
  1266. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1267. #define        (kOuterNeutralTreePercentage,          0.25)
  1268. #define        (kOuterNeutralLandChaos,        0.8)
  1269. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1270. #define        (kOuterNeutralFlatChaos,        0.8)
  1271. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1272.  
  1273. //////////////////////////////////////////////////////////////////////
  1274. // resource definitions
  1275. #define        (kMaxResourceElevation,            4)
  1276. #define        (kResourceToEdgeDistance,        2)
  1277. #define        (kResourceToWaterDistance,        4)
  1278.  
  1279. #define        (kAnimalPerPlayer,            0)
  1280. #define        (kAnimalPerNeutral,            0)
  1281.  
  1282.  
  1283. #define        (kBerryPerNeutral,            0)
  1284.  
  1285. #define        (kFishPerPlayer,                0)
  1286. #define        (kFishPerNeutral,                0)
  1287.  
  1288. #define        (kGoldPerPlayer,                2)
  1289. #define        (kGoldPerNeutral,                2)
  1290.  
  1291. #define        (kOilPerPlayer,                0)
  1292. #define        (kOilPerNeutral,                0)
  1293.  
  1294. #define        (kSteelPerPlayer,                2)
  1295. #define        (kSteelPerNeutral,            2)
  1296.  
  1297. #define        (kStonePerPlayer,                1)
  1298. #define        (kStonePerNeutral,            5)
  1299.  
  1300. #define        (kTreePerPlayer,                0)
  1301. #define        (kTreePerNeutral,                0)
  1302.  
  1303.  
  1304. //////////////////////////////////////////////////////////////////////
  1305. // forest definitions
  1306. #define        (kForestFreeRadius,                7.0)
  1307. #define        (kForestsPerPlayer,                1 )
  1308. #define        (kForestChaosLevel,                1)
  1309. #define        (kMaxClumpsPerForest,                  2)
  1310.  
  1311.  
  1312. #elif Is15Players
  1313. //////////////////////////////////////////////////////////////////////
  1314. // 15 PLAYERS...
  1315. //////////////////////////////////////////////////////////////////////
  1316.  
  1317. //////////////////////////////////////////////////////////////////////
  1318. // terrain definitions
  1319. #define        (kMaxIntElevation,            15)
  1320. #define        (kElevationScale,                Between(1, 1))
  1321. #define        (kHeightMapChaos,                Between(20, 60))
  1322.  
  1323. #define        (kMinimumStartPositionToMapEdge    2)
  1324. #define        (kOuterPushFromMapCenter        20)
  1325. #define        (kInnerPushFromMapCenter         0)    
  1326.                                             
  1327. //////////////////////////////////////////////////////////////////////
  1328. // player definitions
  1329. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1330. #define        (kPlayerInnerRadius,            0.6)
  1331. #define        (kPlayerOuterRadius,            0.95)
  1332. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1333. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1334. #define        (kPlayerLandChaos,            0.8)
  1335. #define        (kPlayerLandClumps,            Between(2, 2))
  1336. #define        (kPlayerFlatChaos,            0.8)
  1337. #define        (kPlayerFlatClumps,            Between(1, 2))
  1338. #define        (kPlayerTreePercentage,            0.08)
  1339.  
  1340. //////////////////////////////////////////////////////////////////////
  1341. // inner neutral definitions
  1342. #define        (kNeutralInnerRadius,            0.3)
  1343. #define        (kNeutralOuterRadius,            0.4)
  1344. #define        (kNeutralOptimalFactor,            0.7)
  1345. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1346. #define        (kInnerNeutralPercentLand,        0.19)
  1347. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1348. #define        (kInnerNeutralTreePercentage,          0.15)
  1349. #define        (kInnerNeutralLandChaos,        0.8)
  1350. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1351. #define        (kInnerNeutralFlatChaos,        0.8)
  1352. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1353.  
  1354. //////////////////////////////////////////////////////////////////////
  1355. // outer neutral definitions
  1356. #define        (kNumOuterNeutrals,            Between(10, 10))
  1357. #define        (kOuterNeutralPercentLand,        0.2)
  1358. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1359. #define        (kOuterNeutralTreePercentage,          0.25)
  1360. #define        (kOuterNeutralLandChaos,        0.8)
  1361. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1362. #define        (kOuterNeutralFlatChaos,        0.8)
  1363. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1364.  
  1365. //////////////////////////////////////////////////////////////////////
  1366. // resource definitions
  1367. #define        (kMaxResourceElevation,            4)
  1368. #define        (kResourceToEdgeDistance,        2)
  1369. #define        (kResourceToWaterDistance,        4)
  1370.  
  1371. #define        (kAnimalPerPlayer,            0)
  1372. #define        (kAnimalPerNeutral,            0)
  1373.  
  1374.  
  1375. #define        (kBerryPerNeutral,            0)
  1376.  
  1377. #define        (kFishPerPlayer,                0)
  1378. #define        (kFishPerNeutral,                0)
  1379.  
  1380. #define        (kGoldPerPlayer,                2)
  1381. #define        (kGoldPerNeutral,                2)
  1382.  
  1383. #define        (kOilPerPlayer,                0)
  1384. #define        (kOilPerNeutral,                0)
  1385.  
  1386. #define        (kSteelPerPlayer,                2)
  1387. #define        (kSteelPerNeutral,            2)
  1388.  
  1389. #define        (kStonePerPlayer,                1)
  1390. #define        (kStonePerNeutral,            5)
  1391.  
  1392. #define        (kTreePerPlayer,                0)
  1393. #define        (kTreePerNeutral,                0)
  1394.  
  1395.  
  1396. //////////////////////////////////////////////////////////////////////
  1397. // forest definitions
  1398. #define        (kForestFreeRadius,                7.0)
  1399. #define        (kForestsPerPlayer,                1 )
  1400. #define        (kForestChaosLevel,                1)
  1401. #define        (kMaxClumpsPerForest,                  2)
  1402.  
  1403. #elif Is16Players
  1404. //////////////////////////////////////////////////////////////////////
  1405. // 16 PLAYERS...
  1406. //////////////////////////////////////////////////////////////////////
  1407.  
  1408. //////////////////////////////////////////////////////////////////////
  1409. // terrain definitions
  1410. #define        (kMaxIntElevation,            15)
  1411. #define        (kElevationScale,                Between(1, 1))
  1412. #define        (kHeightMapChaos,                Between(20, 60))
  1413.  
  1414. #define        (kMinimumStartPositionToMapEdge    2)
  1415. #define        (kOuterPushFromMapCenter        20)
  1416. #define        (kInnerPushFromMapCenter         0)    
  1417.                                             
  1418. //////////////////////////////////////////////////////////////////////
  1419. // player definitions
  1420. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1421. #define        (kPlayerInnerRadius,            0.6)
  1422. #define        (kPlayerOuterRadius,            0.95)
  1423. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1424. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1425. #define        (kPlayerLandChaos,            0.8)
  1426. #define        (kPlayerLandClumps,            Between(2, 2))
  1427. #define        (kPlayerFlatChaos,            0.8)
  1428. #define        (kPlayerFlatClumps,            Between(1, 2))
  1429. #define        (kPlayerTreePercentage,            0.08)
  1430.  
  1431. //////////////////////////////////////////////////////////////////////
  1432. // inner neutral definitions
  1433. #define        (kNeutralInnerRadius,            0.3)
  1434. #define        (kNeutralOuterRadius,            0.4)
  1435. #define        (kNeutralOptimalFactor,            0.7)
  1436. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1437. #define        (kInnerNeutralPercentLand,        0.19)
  1438. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1439. #define        (kInnerNeutralTreePercentage,          0.15)
  1440. #define        (kInnerNeutralLandChaos,        0.8)
  1441. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1442. #define        (kInnerNeutralFlatChaos,        0.8)
  1443. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1444.  
  1445. //////////////////////////////////////////////////////////////////////
  1446. // outer neutral definitions
  1447. #define        (kNumOuterNeutrals,            Between(10, 10))
  1448. #define        (kOuterNeutralPercentLand,        0.2)
  1449. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1450. #define        (kOuterNeutralTreePercentage,          0.25)
  1451. #define        (kOuterNeutralLandChaos,        0.8)
  1452. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1453. #define        (kOuterNeutralFlatChaos,        0.8)
  1454. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1455.  
  1456. //////////////////////////////////////////////////////////////////////
  1457. // resource definitions
  1458. #define        (kMaxResourceElevation,            4)
  1459. #define        (kResourceToEdgeDistance,        2)
  1460. #define        (kResourceToWaterDistance,        4)
  1461.  
  1462. #define        (kAnimalPerPlayer,            0)
  1463. #define        (kAnimalPerNeutral,            0)
  1464.  
  1465.  
  1466. #define        (kBerryPerNeutral,            0)
  1467.  
  1468. #define        (kFishPerPlayer,                0)
  1469. #define        (kFishPerNeutral,                0)
  1470.  
  1471. #define        (kGoldPerPlayer,                2)
  1472. #define        (kGoldPerNeutral,                2)
  1473.  
  1474. #define        (kOilPerPlayer,                0)
  1475. #define        (kOilPerNeutral,                0)
  1476.  
  1477. #define        (kSteelPerPlayer,                2)
  1478. #define        (kSteelPerNeutral,            2)
  1479.  
  1480. #define        (kStonePerPlayer,                1)
  1481. #define        (kStonePerNeutral,            5)
  1482.  
  1483. #define        (kTreePerPlayer,                0)
  1484. #define        (kTreePerNeutral,                0)
  1485.  
  1486.  
  1487. //////////////////////////////////////////////////////////////////////
  1488. // forest definitions
  1489. #define        (kForestFreeRadius,                7.0)
  1490. #define        (kForestsPerPlayer,                1 )
  1491. #define        (kForestChaosLevel,                1)
  1492. #define        (kMaxClumpsPerForest,                  2)
  1493.  
  1494.  
  1495. //////////////////////////////////////////////////////////////////////
  1496. // End of if...elif... command
  1497. #endif
  1498.  
  1499. #endif        // NOTDEFINED(PLAINS_SMALL_RMV)